home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 2000 October / Software of the Month - Ultimate Collection Shareware 277.iso / pc / PROGRAMS / UTILITY / WINLINUX / DATA1.CAB / programs_-_include / ASM-SPAR.{_A / STRING.H < prev    next >
C/C++ Source or Header  |  1999-09-17  |  5KB  |  197 lines
  1. /* $Id: string.h,v 1.14 1998/10/20 03:09:18 jj Exp $
  2.  * string.h: External definitions for optimized assembly string
  3.  *           routines for the Linux Kernel.
  4.  *
  5.  * Copyright (C) 1995,1996 David S. Miller (davem@caip.rutgers.edu)
  6.  * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  7.  */
  8.  
  9. #ifndef __SPARC64_STRING_H__
  10. #define __SPARC64_STRING_H__
  11.  
  12. /* Really, userland/ksyms should not see any of this stuff. */
  13.  
  14. #ifdef __KERNEL__
  15.  
  16. #include <asm/asi.h>
  17.  
  18. extern void __memmove(void *,const void *,__kernel_size_t);
  19. extern __kernel_size_t __memcpy(void *,const void *,__kernel_size_t);
  20. extern __kernel_size_t __memcpy_short(void *,const void *,__kernel_size_t,long,long);
  21. extern __kernel_size_t __memcpy_entry(void *,const void *,__kernel_size_t,long,long);
  22. extern __kernel_size_t __memcpy_16plus(void *,const void *,__kernel_size_t,long,long);
  23. extern __kernel_size_t __memcpy_384plus(void *,const void *,__kernel_size_t,long,long);
  24. extern __kernel_size_t __memset(void *,int,__kernel_size_t);
  25.  
  26. #ifndef EXPORT_SYMTAB_STROPS
  27.  
  28. /* First the mem*() things. */
  29. #define __HAVE_ARCH_BCOPY
  30. #define __HAVE_ARCH_MEMMOVE
  31.  
  32. #undef memmove
  33. #define memmove(_to, _from, _n) \
  34. ({ \
  35.     void *_t = (_to); \
  36.     __memmove(_t, (_from), (_n)); \
  37.     _t; \
  38. })
  39.  
  40. #define __HAVE_ARCH_MEMCPY
  41.  
  42. extern inline void *__constant_memcpy(void *to, const void *from, __kernel_size_t n)
  43. {
  44.     if(n) {
  45.         if(n <= 32) {
  46.             __builtin_memcpy(to, from, n);
  47.         } else {
  48.             __memcpy(to, from, n);
  49.         }
  50.     }
  51.     return to;
  52. }
  53.  
  54. extern inline void *__nonconstant_memcpy(void *to, const void *from, __kernel_size_t n)
  55. {
  56.     __memcpy(to, from, n);
  57.     return to;
  58. }
  59.  
  60. #undef memcpy
  61. #define memcpy(t, f, n) \
  62. (__builtin_constant_p(n) ? \
  63.  __constant_memcpy((t),(f),(n)) : \
  64.  __nonconstant_memcpy((t),(f),(n)))
  65.  
  66. #define __HAVE_ARCH_MEMSET
  67.  
  68. extern inline void *__constant_memset(void *s, char c, __kernel_size_t count)
  69. {
  70.     extern __kernel_size_t __bzero(void *, __kernel_size_t);
  71.  
  72.     if(!c)
  73.         __bzero(s, count);
  74.     else
  75.         __memset(s, c, count);
  76.     return s;
  77. }
  78.  
  79. extern inline void *__nonconstant_memset(void *s, char c, __kernel_size_t count)
  80. {
  81.     __memset(s, c, count);
  82.     return s;
  83. }
  84.  
  85. #undef memset
  86. #define memset(s, c, count) \
  87. (__builtin_constant_p(c) ? \
  88.  __constant_memset((s), (c), (count)) : \
  89.  __nonconstant_memset((s), (c), (count)))
  90.  
  91. #define __HAVE_ARCH_MEMSCAN
  92.  
  93. #undef memscan
  94. #define memscan(__arg0, __char, __arg2)                        \
  95. ({                                        \
  96.     extern void *__memscan_zero(void *, size_t);                \
  97.     extern void *__memscan_generic(void *, int, size_t);            \
  98.     void *__retval, *__addr = (__arg0);                    \
  99.     size_t __size = (__arg2);                        \
  100.                                         \
  101.     if(__builtin_constant_p(__char) && !(__char))                \
  102.         __retval = __memscan_zero(__addr, __size);            \
  103.     else                                    \
  104.         __retval = __memscan_generic(__addr, (__char), __size);        \
  105.                                         \
  106.     __retval;                                \
  107. })
  108.  
  109. #define __HAVE_ARCH_MEMCMP
  110.  
  111. /* Now the str*() stuff... */
  112. #define __HAVE_ARCH_STRLEN
  113.  
  114. extern __kernel_size_t __strlen(const char *);
  115.  
  116. #if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
  117. extern __kernel_size_t strlen(const char *);
  118. #else /* !EGCS */
  119. /* Ugly but it works around a bug in our original sparc64-linux-gcc.  */
  120. #undef strlen
  121. #define strlen(__arg0)                    \
  122. ({    int __strlen_res = __strlen(__arg0) + 1;    \
  123.     __strlen_res -= 1;                \
  124.     __strlen_res;                    \
  125. })
  126. #endif /* !EGCS */
  127.  
  128. #define __HAVE_ARCH_STRNCMP
  129.  
  130. extern int __strncmp(const char *, const char *, __kernel_size_t);
  131.  
  132. extern inline int __constant_strncmp(const char *src, const char *dest, __kernel_size_t count)
  133. {
  134.     register int retval;
  135.     switch(count) {
  136.     case 0: return 0;
  137.     case 1: return (src[0] - dest[0]);
  138.     case 2: retval = (src[0] - dest[0]);
  139.         if(!retval && src[0])
  140.           retval = (src[1] - dest[1]);
  141.         return retval;
  142.     case 3: retval = (src[0] - dest[0]);
  143.         if(!retval && src[0]) {
  144.           retval = (src[1] - dest[1]);
  145.           if(!retval && src[1])
  146.             retval = (src[2] - dest[2]);
  147.         }
  148.         return retval;
  149.     case 4: retval = (src[0] - dest[0]);
  150.         if(!retval && src[0]) {
  151.           retval = (src[1] - dest[1]);
  152.           if(!retval && src[1]) {
  153.             retval = (src[2] - dest[2]);
  154.             if (!retval && src[2])
  155.               retval = (src[3] - dest[3]);
  156.           }
  157.         }
  158.         return retval;
  159.     case 5: retval = (src[0] - dest[0]);
  160.         if(!retval && src[0]) {
  161.           retval = (src[1] - dest[1]);
  162.           if(!retval && src[1]) {
  163.             retval = (src[2] - dest[2]);
  164.             if (!retval && src[2]) {
  165.               retval = (src[3] - dest[3]);
  166.               if (!retval && src[3])
  167.                 retval = (src[4] - dest[4]);
  168.             }
  169.           }
  170.         }
  171.         return retval;
  172.     default:
  173.         retval = (src[0] - dest[0]);
  174.         if(!retval && src[0]) {
  175.           retval = (src[1] - dest[1]);
  176.           if(!retval && src[1]) {
  177.             retval = (src[2] - dest[2]);
  178.             if(!retval && src[2])
  179.               retval = __strncmp(src+3,dest+3,count-3);
  180.           }
  181.         }
  182.         return retval;
  183.     }
  184. }
  185.  
  186. #undef strncmp
  187. #define strncmp(__arg0, __arg1, __arg2)    \
  188. (__builtin_constant_p(__arg2) ?    \
  189.  __constant_strncmp(__arg0, __arg1, __arg2) : \
  190.  __strncmp(__arg0, __arg1, __arg2))
  191.  
  192. #endif /* !EXPORT_SYMTAB_STROPS */
  193.  
  194. #endif /* __KERNEL__ */
  195.  
  196. #endif /* !(__SPARC64_STRING_H__) */
  197.